package com.minglead.crawler.schedule;

import com.minglead.crawler.enums.CrawlerMediaEnum;
import com.minglead.crawler.service.impl.YqModelAnalysisTaskImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.time.LocalTime;
import java.util.Date;

/**
 * @description: 爬虫定时任务
 * @author: tzf
 * @date: 2024-9-29
 **/
@Configuration
@EnableScheduling
@ConditionalOnProperty(name = "scheduling.enabled", havingValue = "true", matchIfMissing = true)
public class YqModelAnalysisTask implements SchedulingConfigurer {

    @Autowired
    private YqModelAnalysisTaskImpl yqModelAnalysisTaskImpl;

    //初始化启动时间戳
    private final long startTime = System.currentTimeMillis();
    //初始化耗时时间 1分钟
    private final int consumeTime = 60000;
    //缓冲时间2分钟
    private final long DelayTime = 120000;

    // 记录上次任务完成的时间戳
    private long toutiaoCompTime = startTime;
    private long weiboCompTime = startTime;
    private long chinaNewsCompTime = startTime;
    private long xinhuaCompTime = startTime;
    private long tencentCompTime = startTime;
    private long sougouWechatCompTime = startTime;

    //分析任务耗时
    private long toutiaoConsumeTime = consumeTime;
    private long weiboConsumeTime = consumeTime;
    private long chinaNewsNetworkConsumeTime = consumeTime;
    private long xinhuaConsumeTime = consumeTime;
    private long tencentConsumeTime = consumeTime;
    private long sougouWechatConsumeTime = consumeTime;

    LocalTime start = LocalTime.of(0, 0); // 凌晨 12:00
    LocalTime end = LocalTime.of(7, 0);   // 早上 7:00

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 创建一个多线程的调度器
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10); // 设定线程池大小，可以根据需要调整
        taskScheduler.initialize();
        taskRegistrar.setTaskScheduler(taskScheduler); // 使用自定义的调度器

        //头条新闻定时模型分析任务
//        System.out.println("初始化今日头条定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动今日头条定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        toutiaoConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.TOUTIAO) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("今日头条定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    toutiaoConsumeTime = 21600000;//6小时
                    toutiaoCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(toutiaoCompTime + toutiaoConsumeTime);
                }
        );

        //微博定时模型分析任务
//        System.out.println("初始化微博定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动微博定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        weiboConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.WEIBO) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("微博定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    weiboConsumeTime = 14400000;//4
                    weiboCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(weiboCompTime + weiboConsumeTime);
                }
        );

        //中国新闻网定时模型分析任务
//        System.out.println("初始化中国新闻网定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动中国新闻网定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        chinaNewsNetworkConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.CHINANEWSNETWORK) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("中国新闻网定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    chinaNewsNetworkConsumeTime = 14400000;//4
                    chinaNewsCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(chinaNewsCompTime + chinaNewsNetworkConsumeTime);
                }
        );

        //新华网定时模型分析任务
//        System.out.println("初始化新华网定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动新华网定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        xinhuaConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.XINHUA) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("新华网定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    xinhuaConsumeTime = 14400000;//4
                    xinhuaCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(xinhuaCompTime + xinhuaConsumeTime);
                }
        );

        //腾讯新闻定时模型分析任务
//        System.out.println("初始化腾讯新闻定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动腾讯新闻定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        tencentConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.TENCENT) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("腾讯新闻定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    tencentConsumeTime = 28800000;//8
                    tencentCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(tencentCompTime + tencentConsumeTime);
                }
        );

        //搜狗微信定时模型分析任务
//        System.out.println("初始化搜狗微信定时任务");
        taskRegistrar.addTriggerTask(() -> {
//                    System.out.println("启动搜狗微信定时任务");
                    // 判断当前时间是否在禁止的时间段内（00:00 - 07:00）
//                    LocalTime now = LocalTime.now();
//                    if (now.isBefore(start) || now.isAfter(end)) {
                        sougouWechatConsumeTime = yqModelAnalysisTaskImpl.analysisTask(CrawlerMediaEnum.SOUGOUWECHAT) + DelayTime;
//                    } else {
//                        // 在 00:00 到 07:00 之间，不执行任务
//                        System.out.println("搜狗微信定时任务暂停执行，时间段为 00:00 - 07:00");
//                    }
                    sougouWechatConsumeTime = 28800000;//8
                    sougouWechatCompTime = System.currentTimeMillis();
                }, triggerContext -> {
                    // 上次完成的时间戳加上分析耗时 作为下次触发的时间
                    return new Date(sougouWechatCompTime + sougouWechatConsumeTime);
                }
        );
    }
}